home *** CD-ROM | disk | FTP | other *** search
Text File | 2002-10-03 | 66.1 KB | 1,387 lines
MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) NNNNAAAAMMMMEEEE _mmmm_aaaa_kkkk_eeee - maintain, update, and regenerate groups of programs (_DDDD_EEEE_VVVV_EEEE_LLLL_OOOO_PPPP_MMMM_EEEE_NNNN_TTTT) SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS _mmmm_aaaa_kkkk_eeee _[[[[_----_eeee_iiii_kkkk_nnnn_pppp_qqqq_rrrr_ssss_SSSS_tttt_uuuu_wwww_dddd_DDDD_PPPP_BBBB_NNNN_MMMM_OOOO_gggg_]]]] _[[[[_----_ffff _m_a_k_e_f_i_l_e_]]]] _...._...._.... _[[[[_m_a_c_r_o_s=_n_a_m_e_]]]] _...._...._.... [_t_a_r_g_e_t__n_a_m_e_]]]] _...._...._.... DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN The _m_a_k_e utility can be used as a part of software development to update files that are derived from other files. A typical case is one where object files are derived from the corresponding source files. The _m_a_k_e utility examines time relationships and updates those derived files (called targets) that have modified times earlier than the modified times of the files (called prerequisites) from which they are derived. A description file (makefile) contains a description of the relationships between files, and the commands that must be executed to update the targets to reflect changes in their prerequisites. Each specification, or rule, consists of a target, optional prerequisites and optional commands to be executed when a prerequisite is newer than the target. There are two types of rule: - inference rules, which have one target name with at least one period (.) and no slash (/) - target rules, which can have more than one target name. In addition, _m_a_k_e has a collection of built-in macros and inference rules that infer prerequisite relationships to simplify maintenance of programs. To receive exactly the behaviour described in this section, a portable makefile must: - include the special target .POSIX - omit any special target reserved for implementations (a leading period followed by upper-case letters) that has not been specified by this section. _NNNN_OOOO_TTTT_EEEE_:::: See _CCCC_OOOO_MMMM_PPPP_AAAA_TTTT_IIII_BBBB_IIII_LLLL_IIII_TTTT_YYYY _IIII_SSSS_SSSS_UUUU_EEEE_SSSS section below for when these conditions are not met. OOOOPPPPTTTTIIIIOOOONNNNSSSS The following options are supported: ----bbbb Compatibility mode for old makefiles. ----BBBB Blocked output. In parallel mode, the output from concurrently updating targets can be either intermingled or saved up and printed upon completion of the target. The default is to intermingle the output, this option turns on the 'blocking' of output until the target has completed. PPPPaaaaggggeeee 1111 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) ----dddd Debug. As targets are traversed, the reason they are being updated is printed. ----DDDD Debug. A full dump of all aspects of target and variable handling. This option usually produces an overwhelming amount of information. ----eeee Cause environment variables, including those with null values, to override macro assignments within makefiles. ----ffff _m_a_k_e_f_i_l_e Specify a different makefile. The argument makefile is a pathname of a description file, which is also referred to as the makefile. A pathname of - denotes the standard input. There can be multiple instances of this option, and they will be processed in the order specified. ----gggg Auto get. If a file does not exist, attempt to 'get' it from SCCS using the $$$$((((GGGGEEEETTTT)))) macro. ----iiii Ignore error codes returned by invoked commands. This mode is the same as if the special target _...._IIII_GGGG_NNNN_OOOO_RRRR_EEEE were specified without prerequisites. ----kkkk Continue to update other targets that do not depend on the current target if a non-ignored error occurs while executing the commands to bring a target up-to-date. ----MMMM Turn off ----NNNN (this is the default). ----nnnn Write commands that would be executed on standard output, but do not execute them. However, lines with a plus sign (_++++) prefix will be executed. In this mode, lines with an at sign (_@@@@) character prefix will be written to standard output. ----NNNN Permit targets that have dependencies to still be candidates for application of the _e_m_p_t_y _r_u_l_e (_N_U_L_L) suffix transformation rules _((((_ssss_eeee_eeee _tttt_hhhh_eeee _""""_IIII_nnnn_ffff_eeee_rrrr_eeee_nnnn_cccc_eeee _RRRR_uuuu_llll_eeee_ssss_"""" _ssss_eeee_cccc_tttt_iiii_oooo_nnnn _bbbb_eeee_llll_oooo_wwww_))))_.... ----OOOO Turn off compatibility mode for old makefiles. ----pppp Write to standard output the complete set of macro definitions and target descriptions. The output format is unspecified. ----PPPP Parallel. Enables building independent parts of the makefile concurrently _((((_ssss_eeee_eeee _""""_PPPP_aaaa_rrrr_aaaa_llll_llll_eeee_llll _EEEE_xxxx_eeee_cccc_uuuu_tttt_iiii_oooo_nnnn_"""" _ssss_eeee_cccc_tttt_iiii_oooo_nnnn _bbbb_eeee_llll_oooo_wwww_))))_.... ----qqqq Return a zero exit value if the target file is up-to-date; otherwise, return an exit value of 1 (one). Targets will not be updated if this option is specified. However, a command PPPPaaaaggggeeee 2222 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) line (associated with the targets) with a plus sign (_++++) prefix will be executed. ----rrrr Clear the suffix list and do not use the built-in rules. ----ssss Do not write command lines or touch messages (see _----_tttt) to standard output before executing. This mode is the same as if the special target _...._SSSS_IIII_LLLL_EEEE_NNNN_TTTT were specified without prerequisites. ----SSSS Terminate _m_a_k_e if an error occurs while executing the commands to bring a target up-to-date. This will be the default and the opposite of the _----_kkkk option. ----tttt Update the modification time of each target as though a _t_o_u_c_h _t_a_r_g_e_t had been executed. Targets that have prerequisites but no commands (see _TTTT_aaaa_rrrr_gggg_eeee_tttt _RRRR_uuuu_llll_eeee_ssss), or that are already up-to-date, will not be touched in this manner. Write messages to standard output for each target file indicating the name of the file and that it was touched. Normally, the command lines associated with each target are not executed. However, a command line with a plus sign (_++++) prefix will be executed. ----uuuu Unconditional. Build all targets regardless of whether they are up-to-date or not. ----wwww Suppress warning messages. Fatal messages will not be affected. If the _----_kkkk and _----_SSSS options are both specified on the command line, by the _M_A_K_E_F_L_A_G_S environment variable, or by the _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS macro, the last one evaluated will take precedence. The _M_A_K_E_F_L_A_G_S environment variable will be evaluated first and the command line will be evaluated second. Assignments to the _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS macro will be evaluated as described in the _""""_EEEE_NNNN_VVVV_IIII_RRRR_OOOO_NNNN_MMMM_EEEE_NNNN_TTTT _VVVV_AAAA_RRRR_IIII_AAAA_BBBB_LLLL_EEEE_SSSS_"""" section. OOOOPPPPEEEERRRRAAAANNNNDDDDSSSS The following operands are supported: _t_a_r_g_e_t__n_a_m_e Target names, as defined in _EEEE_XXXX_TTTT_EEEE_NNNN_DDDD_EEEE_DDDD _DDDD_EEEE_SSSS_CCCC_RRRR_IIII_PPPP_TTTT_IIII_OOOO_NNNN_.... If no target is specified, while _m_a_k_e is processing the makefiles, the first target that _m_a_k_e encounters that is not a special target or an inference rule will be used. _m_a_c_r_o=_n_a_m_e Macro definitions, as defined in the _MMMM_aaaa_cccc_rrrr_oooo_ssss section. PPPPaaaaggggeeee 3333 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) SSSSTTTTDDDDIIIINNNN The standard input will be used only if the makefile option-argument is ----.... See _IIII_NNNN_PPPP_UUUU_TTTT _FFFF_IIII_LLLL_EEEE_SSSS section. IIIINNNNPPPPUUUUTTTT FFFFIIIILLLLEEEESSSS The input file, otherwise known as the makefile, is a text file containing rules, macro definitions and comments. EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS The following environment variables affect the execution of _m_a_k_e: _M_A_K_E_F_L_A_G_S This variable is interpreted as a character string representing a series of option characters to be used as the default options. The implementation will accept both of the following formats (but need not accept them when intermixed): 1. The characters are option letters without the leading hyphens or blank character separation used on a command line. 2. The characters are formatted in a manner similar to a portion of the _m_a_k_e command line: options are preceded by hyphens and blank-character-separated. The _m_a_c_r_o=_n_a_m_e macro definition operands can also be included. The difference between the contents of _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS and the command line is that the contents of the variable will not be subjected to the word expansions. When the command-line options _----f or _----p are used, they will take effect regardless of whether they also appear in _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS_.... The _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS variable will be accessed from the environment before the makefile is read. At that time, all of the options (except _----f and _----p ) and command-line macros not already included in _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS are added to the _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS macro. The _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS macro will be passed into the environment as an environment variable for all child processes. If the _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS macro is subsequently set by the makefile, it replaces the _M_A_K_E_F_L_A_G_S variable currently found in the environment. The value of the _S_H_E_L_L environment variable will not be used as a macro and will not be modified by defining the _SSSS_HHHH_EEEE_LLLL_LLLL macro in a makefile or on the command line. All other environment variables, including those with null values, are used as macros, as defined in the _""""_MMMM_aaaa_cccc_rrrr_oooo_ssss_"""" section. AAAASSSSYYYYNNNNCCCCHHHHRRRROOOONNNNOOOOUUUUSSSS EEEEVVVVEEEENNNNTTTTSSSS If not already ignored, _m_a_k_e will trap SIGHUP, SIGTERM, SIGINT and SIGQUIT and remove the current target unless the target is a directory or the target is a prerequisite of the special target _...._PPPP_RRRR_EEEE_CCCC_IIII_OOOO_UUUU_SSSS or unless one of the _----_nnnn, _----_pppp or _----_qqqq options was specified. Any targets removed in this manner will be reported in diagnostic messages of unspecified format, written to standard error. After this cleanup process, if any, PPPPaaaaggggeeee 4444 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) _m_a_k_e will take the standard action for all other signals. SSSSTTTTDDDDOOOOUUUUTTTT The _m_a_k_e utility will write all commands to be executed to standard output unless the s option was specified, the command is prefixed with an at sign, or the special target _...._SSSS_IIII_LLLL_EEEE_NNNN_TTTT has either the current target as a prerequisite or has no prerequisites. If _m_a_k_e is invoked without any work needing to be done, it will write a message to standard output indicating that no action was taken. SSSSTTTTDDDDEEEERRRRRRRR Used only for diagnostic messages. OOOOUUUUTTTTPPPPUUUUTTTT FFFFIIIILLLLEEEESSSS None. However, utilities invoked by _m_a_k_e may create additional files. EEEEXXXXTTTTEEEENNNNDDDDEEEEDDDD DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN The _m_a_k_e utility attempts to perform the actions required to ensure that the specified targets are up-to-date. A target is considered out-of-date if it is older than any of its prerequisites or if it does not exist. The _m_a_k_e utility treats all prerequisites as targets themselves and recursively ensures that they are up-to-date, processing them in the order in which they appear in the rule. The _m_a_k_e utility uses the modification times of files to determine if the corresponding targets are out-of-date. After _m_a_k_e has ensured that all of the prerequisites of a target are up- to-date and if the target is out-of-date, the commands associated with the target entry are executed. If there are no commands listed for the target, the target is treated as up-to-date. MMMMaaaakkkkeeeeffffiiiilllleeee SSSSyyyynnnnttttaaaaxxxx A makefile can contain rules, macro definitions, and comments. There are two kinds of rules: inference rules and target rules. The _m_a_k_e utility contains a set of built-in inference rules. If the _----r option is present, the built-in rules are not used and the suffix list is cleared. Additional rules of both types can be specified in a makefile. If a rule or macro is defined more than once, the value of the rule or macro will be that of the last one specified. Comments start with a number sign (_####) and continue until an unescaped newline character is reached. By default, the following files are tried in sequence: ....////mmmmaaaakkkkeeeeffffiiiilllleeee,,,, ....////MMMMaaaakkkkeeeeffffiiiilllleeee,,,, ....////ssss....mmmmaaaakkkkeeeeffffiiiilllleeee,,,, SSSSCCCCCCCCSSSS////ssss....mmmmaaaakkkkeeeeffffiiiilllleeee,,,, ....////ssss....MMMMaaaakkkkeeeeffffiiiilllleeee and _SSSS_CCCC_CCCC_SSSS_////_ssss_...._MMMM_aaaa_kkkk_eeee_ffff_iiii_llll_eeee_.... The _----f option directs _m_a_k_e to ignore any of these default files and use the specified argument as a makefile instead. If the _---- argument is specified, standard input will be used. PPPPaaaaggggeeee 5555 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) The term makefile is used to refer to any rules provided by the user, whether in The rules in makefiles consist of the following types of lines: target rules, including special targets (see _TTTT_aaaa_rrrr_gggg_eeee_tttt _RRRR_uuuu_llll_eeee_ssss); inference rules (see _IIII_nnnn_ffff_eeee_rrrr_eeee_nnnn_cccc_eeee _RRRR_uuuu_llll_eeee_ssss); macro definitions (see _MMMM_aaaa_cccc_rrrr_oooo_ssss); empty lines; and comments. Comments start with a number sign (_####) and continue until an unescaped newline character is reached. When an escaped newline character (one preceded by a _bbbb_aaaa_cccc_kkkk_ssss_llll_aaaa_ssss_hhhh) is found anywhere in the makefile, it is replaced, along with any leading white space on the following line, with a single space character. MMMMaaaakkkkeeeeffffiiiilllleeee EEEExxxxeeeeccccuuuuttttiiiioooonnnn Command lines are processed one at a time by writing the command line to the standard output (unless one of the conditions listed below under _@@@@ suppresses the writing) and executing the commands in the line. A tab character may precede the command to standard output. Commands will be executed by passing the command line to the command interpreter in the same manner as if the string were the argument to the _s_y_s_t_e_m() function. The environment for the command being executed will contain all of the variables in the environment of _m_a_k_e. The macros from the command line to _m_a_k_e will be added to _m_a_k_e'_s environment. Other implementation-dependent variables may also be added to _m_a_k_e'_s environment. If any command-line macro has been defined elsewhere, the command-line value will overwrite the existing value. If the _M_A_K_E_F_L_A_G_S variable is not set in the environment in which _m_a_k_e was invoked, in the makefile or on the command line, it will be created by _m_a_k_e, and will contain all options specified on the command line except for the _----_ffff and _----_pppp options. It may also contain implementation-dependent options. By default, when _m_a_k_e receives a non-zero status from the execution of a command, it terminates with an error message to standard error. Command lines can have one or more of the following prefixes: a hyphen (_----), an at sign (_@@@@), or a plus sign (_++++). These modify the way in which _m_a_k_e processes the command. When a command is written to standard output, the prefix is not included in the output. ---- If the command prefix contains a hyphen, or the _----_iiii option is present, or the special target _...._IIII_GGGG_NNNN_OOOO_RRRR_EEEE has either the current target as a prerequisite or has no prerequisites, any error found while executing the command will be ignored. @@@@ If the command prefix contains an at sign and the command-line n option is not specified, or the s option is present, or the special target _...._SSSS_IIII_LLLL_EEEE_NNNN_TTTT has either the current target as a prerequisite or has no prerequisites, the command will not be written to standard output before it is executed. PPPPaaaaggggeeee 6666 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) ++++ If the command prefix contains a plus sign, this indicates a command line that will be executed even if _----_nnnn, _----_qqqq or _----_tttt is specified. IIIInnnncccclllluuuuddddeeee FFFFiiiilllleeeessss If the string _i_n_c_l_u_d_e or _s_i_n_c_l_u_d_e appears at the beginning of a line in a _m_a_k_e_f_i_l_e, and is followed by a blank or a tab, the rest of the line is assumed to be a filename and will be read by the current invocation, after substituting for any macros. For _i_n_c_l_u_d_e it is a fatal error if the file is not readable, for _s_i_n_c_l_u_d_e a non-readable file is silently ignored. AAAAlllltttteeeerrrrnnnnaaaatttteeee MMMMaaaakkkkeeee _m_a_k_e understands a convention similar to the alternate interpreter feature of _e_x_e_c(_2) . If the first line of the makefile starts with a ####!!!!aaaalllltttteeeerrrrnnnnaaaatttteeee____mmmmaaaakkkkeeee ,,,, then _m_a_k_e will attempt to _e_x_e_c the alternate make with the same environment and arguments that _m_a_k_e itself was invoked with. Additional arguments may be supplied on the ####!!!! line - these are placed ahead of all the command line arguments given to the original invocation of _m_a_k_e . If a new makefile specification is given using the ----ffff flag, any original ----ffff options given on the command line are ignored. If the alternate make cannot be found in the user's PPPPAAAATTTTHHHH or make finds that it would be re-invoking itself, then make silently ignores the line and continues to execute the remainder of the makefile. The ----dddd flag will display information as to whether the alternate make was successfully invoked. As a special case to support compatibility with a makefile used as a shell script (with a "#!/bin/make -f"), a lone ----ffff flag is ignored. PPPPaaaarrrraaaalllllllleeeellll EEEExxxxeeeeccccuuuuttttiiiioooonnnn The ----PPPP option turns on parallel execution. In this mode _m_a_k_e views all dependencies for a given target as independent, and works on a set of them concurrently. By default, the concurrency factor is two. This may be changed by setting the environment variable _P_A_R_A_L_L_E_L. Note that some makefiles make use of the property that in the non-parallel versions of make dependencies were brought up to date in the order listed. The following makefile relies on this ordering and thus would not work correctly when invoked with the parallel option: default: a b a: mkdir foo b: cd foo; echo hi TTTTaaaarrrrggggeeeetttt RRRRuuuulllleeeessss Target rules are formatted as follows: PPPPaaaaggggeeee 7777 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) _t_a_r_g_e_t [_t_a_r_g_e_t...]: [_p_r_e_r_e_q_u_i_s_i_t_e...][; _c_o_m_m_a_n_d ] [<_t_a_b> _c_o_m_m_a_n_d <_t_a_b> _c_o_m_m_a_n_d ...] _l_i_n_e _t_h_a_t _d_o_e_s _n_o_t _b_e_g_i_n _w_i_t_h <_t_a_b> Target entries are specified by a blank-character-separated, non-null list of targets, then a colon, then a blank-character-separated, possibly empty list of prerequisites. Text following a semicolon, if any, and all following lines that begin with a tab character, are command lines to be executed to update the target. The first non-empty line that does not begin with a tab character or _#### begins a new entry. An empty or blank line, or a line beginning with _####_,,,, may begin a new entry. Applications must select target names from the set of characters consisting solely of periods, underscores, digits and alphabetics from the portable character set. Implementations may allow other characters in target names as extensions. The interpretation of targets containing the characters (_%%%%) and (_"""") is implementation-dependent. A target that has prerequisites, but does not have any commands, can be used to add to the prerequisite list for that target. Only one target rule for any given target can contain commands. Lines that begin with one of the following are called special targets and control the operation of _m_a_k_e: ....DDDDEEEEFFFFAAAAUUUULLLLTTTT If the makefile uses this special target, it must be specified with commands, but without prerequisites. The commands will be used by _m_a_k_e if there are no other rules available to build a target. ....IIIIGGGGNNNNOOOORRRREEEE Prerequisites of this special target are targets themselves; this will cause errors from commands associated with them to be ignored in the same manner as specified by the _----_iiii option. Subsequent occurrences of ....IIIIGGGGNNNNOOOORRRREEEE add to the list of targets ignoring command errors. If no prerequisites are specified, _m_a_k_e will behave as if the _----_iiii option had been specified and errors from all commands associated with all targets will be ignored. ....MMMMAAAAKKKKEEEEOOOOPPPPTTTTSSSS Any command line option except ----[[[[rrrreeeeffff]]]] may be set in a makefile by listing it as a dependency to this target. Note that this is a target not a macro; do not assign (using an '=') a value to it. ....PPPPOOOOSSSSIIIIXXXX This special target must be specified without prerequisites or commands. If it appears before the first non-comment line in the makefile, _m_a_k_e will process the makefile as specified by this section; otherwise, the behaviour of _m_a_k_e is unspecified. PPPPaaaaggggeeee 8888 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) ....PPPPRRRREEEECCCCIIIIOOOOUUUUSSSS Prerequisites of this special target will not be removed if _m_a_k_e receives one of the asynchronous events explicitly described in AAAASSSSYYYYNNNNCCCCHHHHRRRROOOONNNNOOOOUUUUSSSS EEEEVVVVEEEENNNNTTTTSSSS.... Subsequent occurrences of ....PPPPRRRREEEECCCCIIIIOOOOUUUUSSSS add to the list of precious files. If no prerequisites are specified, all targets in the makefile will be treated as if specified with ....PPPPRRRREEEECCCCIIIIOOOOUUUUSSSS.... ....SSSSCCCCCCCCSSSS____GGGGEEEETTTT This special target must be specified without prerequisites. If this special target is included in a makefile, the commands specified with this target replace the default commands associated with this special target. (See "_DDDD_eeee_ffff_aaaa_uuuu_llll_tttt _RRRR_uuuu_llll_eeee_ssss_""""). The commands specified with this target are used to get all SCCS files that are not found in the current directory. When source files are named in a dependency list, _m_a_k_e treats them just like any other target. Because the source file is presumed to be present in the directory, there is no need to add an entry for it to the makefile. When a target has no dependencies, but is present in the directory, _m_a_k_e assumes that that file is up-to-date. If, however, an SCCS file named _SSSS_CCCC_CCCC_SSSS_////_ssss.source_file is found for a target _s_o_u_r_c_e__f_i_l_e, _m_a_k_e does some additional checking to assure that the target is up-to-date. If the target is missing, or if the SCCS file is newer, _m_a_k_e automatically issues the commands specified for the ....SSSSCCCCCCCCSSSS____GGGGEEEETTTT special target to retrieve the most recent version. However, if the target is writable by anyone, _m_a_k_e does not retrieve a new version. ....SSSSIIIILLLLEEEENNNNTTTT Prerequisites of this special target are targets themselves; this causes commands associated with them to not be written to the standard output before they are executed. Subsequent occurrences of ....SSSSIIIILLLLEEEENNNNTTTT add to the list of targets with silent commands. If no prerequisites are specified, _m_a_k_e will behave as if the _----_ssss option had been specified and no commands or touch messages associated with any target will be written to standard output. ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS Prerequisites of ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS are appended to the list of known suffixes and are used in conjunction with the inference rules (see "_IIII_nnnn_ffff_eeee_rrrr_eeee_nnnn_cccc_eeee _RRRR_uuuu_llll_eeee_ssss" ). If ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS does not have any prerequisites, the list of known suffixes will be cleared. Makefiles must not associate commands with ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS.... Targets with names consisting of a leading period followed by the upper-case letters POSIX and then any other characters are reserved for future standardisation. Targets with names consisting of a leading period followed by one or more upper-case letters are reserved for implementation extensions. PPPPaaaaggggeeee 9999 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) MMMMaaaaccccrrrroooossss Macro definitions are in the form: _s_t_r_i_n_g_1 = [ _s_t_r_i_n_g_2 ] The macro named _s_t_r_i_n_g_1 is defined as having the value of _s_t_r_i_n_g_2, where _s_t_r_i_n_g_2 is defined as all characters, if any, after the equal sign, up to a comment character (_####) or an unescaped newline character. Any blank characters immediately before or after the equal sign will be ignored. Subsequent appearances of $(_s_t_r_i_n_g_1) or ${_s_t_r_i_n_g_1} _a_r_e _r_e_p_l_a_c_e_d _b_y _s_t_r_i_n_g_2. The parentheses or braces are optional if _s_t_r_i_n_g_1 is a single character. The macro _$$$$_$$$$ is replaced by the single character _$$$$ in effect escaping the _$$$$ character. See _NNNN_OOOO_TTTT_EEEE_SSSS below about macros defined within macros. Applications must select macro names from the set of characters consisting solely of periods, underscores, digits and alphabetics from the portable character set. A macro name cannot contain an equal sign. Implementations may allow other characters in macro names as extensions. Macros can appear anywhere in the makefile. Macros in target lines will be evaluated when the target line is read. Macros in command lines will be evaluated when the command is executed. Macros in macro definition lines will not be evaluated until the new macro being defined is used in a rule or command. A macro that has not been defined will evaluate to a null string without causing any error condition. The forms $$$$((((ssssttttrrrriiiinnnngggg1111[[[[::::ssssuuuubbbbsssstttt1111====[[[[ssssuuuubbbbsssstttt2222]]]]]]]])))) or $$$${{{{ssssttttrrrriiiinnnngggg1111[[[[::::ssssuuuubbbbsssstttt1111====[[[[ssssuuuubbbbsssstttt2222]]]]]]]]}}}} can be used to replace all occurrences of _s_u_b_s_t_1 with _s_u_b_s_t_2 when the macro substitution is performed. The _s_u_b_s_t_1 to be replaced is recognised when it is a suffix at the end of a word in _s_t_r_i_n_g_1 (where a _w_o_r_d, in this context, is defined to be a string delimited by the beginning of the line, a blank or newline character). Macro assignments will be accepted from the sources listed below, in the order shown. If a macro name already exists at the time it is being processed, the newer definition will replace the existing definition. 1. Macros defined in _m_a_k_e'_s built-in inference rules. 2. The contents of the environment, including the variables with null values, in the order defined in the environment. 3. Macros defined in the makefiles, processed in the order specified. 4. Macros specified on the command line. It is unspecified whether the internal macros defined in _IIII_nnnn_tttt_eeee_rrrr_nnnn_aaaa_llll _MMMM_aaaa_cccc_rrrr_oooo_ssss are accepted from the command line. PPPPaaaaggggeeee 11110000 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) If the _----_eeee option is specified, the order of processing sources items 2 and 3 will be reversed. The _SSSS_HHHH_EEEE_LLLL_LLLL macro is treated specially. It is provided by _m_a_k_e and set to the pathname of the shell command language interpreter (see The _S_H_E_L_L environment variable will not affect the value of the _SSSS_HHHH_EEEE_LLLL_LLLL macro. If _SSSS_HHHH_EEEE_LLLL_LLLL is defined in the makefile or is specified on the command line, it will replace the original value of the _SSSS_HHHH_EEEE_LLLL_LLLL macro, but will not affect the _S_H_E_L_L environment variable. Other effects of defining _SSSS_HHHH_EEEE_LLLL_LLLL in the makefile or on the command line are implementation-dependent. IIIInnnnffffeeeerrrreeeennnncccceeee RRRRuuuulllleeeessss Inference rules are formatted as follows: _t_a_r_g_e_t: <_t_a_b>_c_o_m_m_a_n_d [<_t_a_b>_c_o_m_m_a_n_d ] ... _l_i_n_e _t_h_a_t _d_o_e_s _n_o_t _b_e_g_i_n _w_i_t_h <_t_a_b> _o_r # The _t_a_r_g_e_t portion must be a valid target name (see "_TTTT_aaaa_rrrr_gggg_eeee_tttt _RRRR_uuuu_llll_eeee_ssss") of the form ._s_2 or ._s_1._s_2 (where ._s_1 and ._s_2 are suffixes that have been given as prerequisites of the _...._SSSS_UUUU_FFFF_FFFF_IIII_XXXX_EEEE_SSSS special target and _s_1 and _s_2 do not contain any slashes or periods.) If there is only one period in the target, it is a single-suffix inference rule. Targets with two periods are double-suffix inference rules. Inference rules can have only one target before the colon. The makefile must not specify prerequisites for inference rules; no characters other than white space can follow the colon in the first line, except when creating the _e_m_p_t_y _r_u_l_e, described below. Prerequisites are inferred, as described below. Inference rules can be redefined. A target that matches an existing inference rule will overwrite the old inference rule. An empty rule can be created with a command consisting of simply a semicolon (that is, the rule still exists and is found during inference rule search, but since it is empty, execution has no effect). The empty rule also can be formatted as follows: _r_u_l_e: ; where zero or more blank characters separate the colon and semicolon. The _m_a_k_e utility uses the suffixes of targets and their prerequisites to infer how a target can be made up-to-date. A list of inference rules defines the commands to be executed. By default, _m_a_k_e contains a built-in set of inference rules. Additional rules can be specified in the makefile. PPPPaaaaggggeeee 11111111 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) The special target ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS contains as its prerequisites a list of suffixes that are to be used by the inference rules. The order in which the suffixes are specified defines the order in which the inference rules for the suffixes are used. New suffixes will be appended to the current list by specifying a ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS special target in the makefile. A ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS target with no prerequisites will clear the list of suffixes. An empty ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS target followed by a new ....SSSSUUUUFFFFFFFFIIIIXXXXEEEESSSS list is required to change the order of the suffixes. Normally, the user would provide an inference rule for each suffix. The inference rule to update a target with a suffix ._s_1 from a prerequisite with a suffix ._s_2 is specified as a target ._s_2._s_1. The internal macros provide the means to specify general inference rules. (See _IIII_nnnn_tttt_eeee_rrrr_nnnn_aaaa_llll _MMMM_aaaa_cccc_rrrr_oooo_ssss) When no target rule is found to update a target, the inference rules are checked. The suffix of the target (._s_1) to be built is compared to the list of suffixes specified by the ._s_1 suffix is found in _...._SSSS_UUUU_FFFF_FFFF_IIII_XXXX_EEEE_SSSS_,,,, the inference rules are searched in the order defined for the first ._s_2._s_1 rule whose prerequisite file (_$$$$_****.s2) exists. If the target is out-of-date with respect to this prerequisite, the commands for that inference rule are executed. If the target to be built does not contain a suffix and there is no rule for the target, the single suffix inference rules will be checked. The single-suffix inference rules define how to build a target if a file is found with a name that matches the target name with one of the single suffixes appended. A rule with one suffix ._s_2 is the definition of how to build _t_a_r_g_e_t from _t_a_r_g_e_t._s_2. The other suffix (._s_1) is treated as null. A tilde (_~~~~) in the above rules refers to an SCCS file in the current directory. Thus, the rule ....cccc....oooo would transform an SCCS C-language source file into an object file ((((....oooo)))).... Because the ssss.... of the SCCS files is a prefix, it is incompatible with _m_a_k_e'_s suffix point of view. Hence, the ~~~~ is a way of changing any file reference into an SCCS file reference. LLLLiiiibbbbrrrraaaarrrriiiieeeessss If a target or prerequisite contains parentheses, it will be treated as a member of an archive library. For the _l_i_b(_m_e_m_b_e_r._o) expression _l_i_b refers to the name of the archive library and _m_e_m_b_e_r._o to the member name. The member must be an object file with the ._o suffix. The modification time of the expression is the modification time for the member as kept in the archive library (_S_e_e _a_r). The ....aaaa suffix refers to an archive library. The ._s_2._aaaa rule is used to update a member in the library from a file with a suffix ._s_2. IIIInnnntttteeeerrrrnnnnaaaallll MMMMaaaaccccrrrroooossss The _m_a_k_e utility maintains five internal macros that can be used in target and inference rules. In order to clearly define the meaning of these macros, some clarification of the terms _t_a_r_g_e_t _r_u_l_e, _i_n_f_e_r_e_n_c_e PPPPaaaaggggeeee 11112222 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) _r_u_l_e, _t_a_r_g_e_t and _p_r_e_r_e_q_u_i_s_i_t_e is necessary. Target rules are specified by the user in a makefile for a particular target. Inference rules are user- or _m_a_k_e -specified rules for a particular class of target names. Explicit prerequisites are those prerequisites specified in a makefile on target lines. Implicit prerequisites are those prerequisites that are generated when inference rules are used. Inference rules are applied to implicit prerequisites or to explicit prerequisites that do not have target rules defined for them in the makefile. Target rules are applied to targets specified in the makefile. Before any target in the makefile is updated, each of its prerequisites (both explicit and implicit) will be updated. This is accomplished by recursively processing each prerequisite. Upon recursion, each prerequisite becomes a target itself. Its prerequisites in turn are processed recursively until a target is found that has no prerequisites, at which point the recursion stops. The recursion then backs up, updating each target as it goes. In the definitions that follow, the word _t_a_r_g_e_t refers to one of: - a target specified in the makefile - an explicit prerequisite specified in the makefile that becomes the target when _m_a_k_e processes it during recursion - an implicit prerequisite that becomes a target when _m_a_k_e processes it during recursion. In the definitions that follow, the word _p_r_e_r_e_q_u_i_s_i_t_e refers to one of the following: - an explicit prerequisite specified in the makefile for a particular target - an implicit prerequisite generated as a result of locating an appropriate inference rule and corresponding file that matches the suffix of the target. The internal macros are: $$$$@@@@ The $@ evaluates to the full target name of the current target, or the archive filename part of a library archive target. It is evaluated for both target and inference rules. For example, in the ....cccc....aaaa inference rule, $@ represents the out-of-date ....aaaa file to be built. Similarly, in a makefile target rule to build lllliiiibbbb....aaaa from ffffiiiilllleeee....cccc,,,, $@ represents the out-of-date lllliiiibbbb....aaaa.... $$$$$$$$@@@@ The $$@ macro stands for the full target name of the current target (which is $$$$@@@@). It has meaning only on the dependency line in a makefile. Thus, in the following: PPPPaaaaggggeeee 11113333 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) cat dd: $$@.c the dependency is translated at execution time first to the string ccccaaaatttt....cccc,,,, then to the string dddddddd....cccc.... $$$$%%%% The $% macro is evaluated only when the current target is an archive library member of the form _l_i_b_n_a_m_e(_m_e_m_b_e_r_...._oooo). In these cases, $@ evaluates to _l_i_b_n_a_m_e and $% evaluates to _m_e_m_b_e_r._oooo_.... The $% macro is evaluated for both target and inference rules. For example, in a makefile target rule to build lllliiiibbbb....aaaa((((ffffiiiilllleeee....oooo)))),,,, $% represents ffffiiiilllleeee....oooo as opposed to $@, which represents lllliiiibbbb....aaaa.... $$$$???? The $? macro evaluates to the list of prerequisites that are newer than the current target. It is evaluated for both target and inference rules. For example, in a makefile target rule to build pppprrrroooogggg from ffffiiiilllleeee1111....oooo,,,, ffffiiiilllleeee2222....oooo and ffffiiiilllleeee3333....oooo,,,, and where pppprrrroooogggg is not out of date with respect to ffffiiiilllleeee1111....oooo,,,, but is out of date with respect to ffffiiiilllleeee2222....oooo and ffffiiiilllleeee3333....oooo,,,, $? represents ffffiiiilllleeee2222....oooo and ffffiiiilllleeee3333....oooo.... $$$$<<<< In an inference rule, $< evaluates to the file name whose existence allowed the inference rule to be chosen for the target. In the ....DDDDEEEEFFFFAAAAUUUULLLLTTTT rule, the $< macro evaluates to the current target name. The $< macro is evaluated only for inference rules. For example, in the ....cccc....aaaa inference rule, $< represents the prerequisite ....cccc file. $$$$**** The $* macro evaluates to the current target name with its suffix deleted. It is evaluated at least for inference rules. For example, in the ....cccc....aaaa inference rule, $*.o represents the out-of-date ....oooo file that corresponds to the prerequisite ....cccc file. Each of the internal macros has an alternative form. When an upper-case D or F is appended to any of the macros, the meaning is changed to the _d_i_r_e_c_t_o_r_y _p_a_r_t for D and _f_i_l_e_n_a_m_e part for F. The directory part is the path prefix of the file without a trailing slash; for the current directory, the directory part is ``.''. When the $? macro contains more than one prerequisite filename, the $(?D) and $(?F) (or ${?D} and ${?F}) macros expand to a list of directory name parts and filename parts respectively. For the target _l_i_b(_m_e_m_b_e_r._o) and the ssss2222....aaaa rule, the internal macros are defined as: $$$$<<<< _m_e_m_b_e_r._ssss_2222 PPPPaaaaggggeeee 11114444 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) $$$$**** _m_e_m_b_e_r $$$$@@@@ _l_i_b $$$$???? _m_e_m_b_e_r._ssss_2222 $$$$%%%% _m_e_m_b_e_r._oooo DDDDeeeeffffaaaauuuulllltttt RRRRuuuulllleeeessss The default rules for _m_a_k_e achieve results that are the same as if the following were used. SSSSPPPPEEEECCCCIIIIAAAALLLL TTTTAAAARRRRGGGGEEEETTTTSSSS:::: .SCCS_GET: sccs $(SCCSFLAGS) get $(SCCSGETFLAGS) $@ .SUFFIXES: .o .c .y l .a .sh .f .c~ .y~ .l~ .sh~ .f~ MMMMAAAACCCCRRRROOOOSSSS:::: MAKE=make AR=ar ARFLAGS=-rv YACC=yacc YFLAGS= LEX=lex LFLAGS= LDFLAGS= CC=c89 CFLAGS=-O FC=fort77 FFLAGS=-O 1 GET=get GFLAGS= SCCSFLAGS= SCCSGETFLAGS=-s SSSSIIIINNNNGGGGLLLLEEEE SSSSUUUUFFFFFFFFIIIIXXXX RRRRUUUULLLLEEEESSSS .c: $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< .f: $(FC) $(FFLAGS) $(LDFLAGS) -o $@ $< .sh: cp $< $@ chmod a+x $@ .c~: $(GET) $(GFLAGS) -p $< > $*.c $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $*.c PPPPaaaaggggeeee 11115555 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) .f~: $(GET) $(GFLAGS) -p $< > $*.f $(FC) $(FFLAGS) $(LDFLAGS) -o $@ $*.f .sh~: $(GET) $(GFLAGS) -p $< > $*.sh cp $*.sh $@ chmod a+x $@ DDDDOOOOUUUUBBBBLLLLEEEE SSSSUUUUFFFFFFFFIIIIXXXX RRRRUUUULLLLEEEESSSS .c.o: $(CC) $(CFLAGS) -c $< .f.o: $(FC) $(FFLAGS) -c $< .y.o: $(YACC) $(YFLAGS) $< $(CC) $(CFLAGS) -c y.tab.c rm -f y.tab.c mv y.tab.o $@ .l.o: $(LEX) $(LFLAGS) $< $(CC) $(CFLAGS) -c lex.yy.c rm -f lex.yy.c mv lex.yy.o $@ .y.c: $(YACC) $(YFLAGS) $< mv y.tab.c $@ .l.c: $(LEX) $(LFLAGS) $< mv lex.yy.c $@ .c~.o: $(GET) $(GFLAGS) -p $< > $*.c $(CC) $(CFLAGS) -c $*.c .f~.o: $(GET) $(GFLAGS) -p $< > $*.f $(FC) $(FFLAGS) -c $*.f .y~.o: $(GET) $(GFLAGS) -p $< > $*.y $(YACC) $(YFLAGS) $*.y $(CC) $(CFLAGS) -c y.tab.c rm -f y.tab.c mv y.tab.o $@ PPPPaaaaggggeeee 11116666 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) .l~.o: $(GET) $(GFLAGS) -p $< > $*.l $(LEX) $(LFLAGS) $*.l $(CC) $(CFLAGS) -c lex.yy.c rm -f lex.yy.c mv lex.yy.o $@ .y~.c: $(GET) $(GFLAGS) -p $< > $*.y $(YACC) $(YFLAGS) $*.y mv y.tab.c $@ .l~.c: $(GET) $(GFLAGS) -p $< > $*.l $(LEX) $(LFLAGS) $*.l mv lex.yy.c $@ .c.a: $(CC) -c $(CFLAGS) $< $(AR) $(ARFLAGS) $@ $*.o rm -f $*.o .f.a: $(FC) -c $(FFLAGS) $< $(AR) $(ARFLAGS) $@ $*.o rm -f $*.o EEEEXXXXIIIITTTT SSSSTTTTAAAATTTTUUUUSSSS When the ----qqqq option is specified, the _m_a_k_e utility will exit with one of the following values: 0 Successful completion. 1 The target was not up-to-date. >1 An error occurred. When the ----qqqq option is not specified, the _m_a_k_e utility will exit with one of the following values: 0 successful completion >0 an error occurred AAAAPPPPPPPPLLLLIIIICCCCAAAATTTTIIIIOOOONNNN UUUUSSSSAAAAGGGGEEEE If there is a source file (such as ....////ssssoooouuuurrrrcccceeee....cccc)))) and there are two SCCS files corresponding to it ((((....////ssss....ssssoooouuuurrrrcccceeee....cccc and ....////SSSSCCCCCCCCSSSS////ssss....ssssoooouuuurrrrcccceeee....cccc)))),,,, _m_a_k_e will use the SCCS file in the current directory. However, users are advised to use the underlying SCCS utilities (_a_d_m_i_n, _d_e_l_t_a, _g_e_t, and so forth) or the sccs utility for all source files in a given directory. If both forms are used for a given source file, future developers may be confused. PPPPaaaaggggeeee 11117777 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) It is incumbent upon portable makefiles to specify the ....PPPPOOOOSSSSIIIIXXXX special target in order to guarantee that they are not affected by local extensions. The ----kkkk and ----SSSS options are both present so that the relationship between the command line, the _M_A_K_E_F_L_A_G_S variable, and the makefile can be controlled precisely. If the ----kkkk flag is passed in _M_A_K_E_F_L_A_G_S and a command is of the form: $(MAKE) -S foo then the default behaviour is restored for the child _m_a_k_e. When the ----nnnn option is specified, it is always added to _M_A_K_E_F_L_A_G_S. This allows a recursive _m_a_k_e ----nnnn _t_a_r_g_e_t to be used to see all of the action that would be taken to update _t_a_r_g_e_t. Because of widespread historical practice, interpreting a # number sign inside a variable as the start of a comment has the unfortunate side effect of making it impossible to place a number sign in a variable, thus forbidding something like: CFLAGS = "-D COMMENT_CHAR='#'" Many historical _m_a_k_e utilities stop chaining together inference rules when an intermediate target is non-existent. For example, it might be possible for a _m_a_k_e to determine that both .y.c and .c.o could be used to convert a .y to a .o. Instead, in this case, _m_a_k_e requires the use of a .y.o rule. The best way to provide portable makefiles is to include all of the rules needed in the makefile itself. The rules provided use only features provided by other parts of the standard. The default rules include rules for optional commands in the standard. Only rules pertaining to commands that are provided are needed in an implementation's default set. Macros used within other macros are evaluated when the new macro is used rather than when the new macro is defined. Therefore: MACRO = _v_a_l_u_e_1 NEW = $(MACRO) MACRO = _v_a_l_u_e_2 target: echo $(NEW) would produce _v_a_l_u_e_2 and not _v_a_l_u_e_1 since NNNNEEEEWWWW was not expanded until it was needed in the _e_c_h_o command line. Some historical applications have been known to intermix _t_a_r_g_e_t__n_a_m_e and _m_a_c_r_o=_n_a_m_e operands on the command line, expecting that all of the macros will be processed before any of the targets are dealt with. Portable PPPPaaaaggggeeee 11118888 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) applications do not do this, although some backward compatibility support may be included in some implementations. The following characters in filenames may give trouble: = : ` ' @ For inference rules, the description of $< and $? seem similar. However, an example shows the minor difference. In a makefile containing: foo.o: foo.h if ffffoooooooo....hhhh is newer than ffffoooooooo....oooo,,,, yet ffffoooooooo....cccc is older than ffffoooooooo....oooo,,,, the built-in rule to make ffffoooooooo....oooo from ffffoooooooo....cccc will be used, with $< equal to ffffoooooooo....cccc and $? equal to ffffoooooooo....hhhh.... If ffffoooooooo....cccc is also newer than ffffoooooooo....oooo,,,, $< is equal to ffffoooooooo....cccc and $? is equal to ffffoooooooo....hhhh ffffoooooooo....cccc.... EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS 1. The following command: make makes the first target found in the makefile. 2. The following command: make junk makes the target junk. 3. The following makefile says that ppppggggmmmm depends on two files, aaaa....oooo and bbbb....oooo,,,, and that they in turn depend on their corresponding source files ((((aaaa....cccc and bbbb....cccc)))),,,, and a common file iiiinnnnccccllll....hhhh:::: pgm: a.o b.o c89 a.o b.o -o pgm a.o: incl.h a.c c89 -c a.c b.o: incl.h b.c c89 -c b.c 4. An example for making optimised ....oooo files from ....cccc files is: .c.o: c89 -c -O $*.c or: .c.o: c89 -c -O $< PPPPaaaaggggeeee 11119999 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) 5. The most common use of the archive interface follows. Here, it is assumed that the source files are all C-language source: lib: lib(file1.o) lib(file2.o) lib(file3.o) @echo lib is now up-to-date The ....cccc....aaaa rule is used to make ffffiiiilllleeee1111....oooo,,,, ffffiiiilllleeee2222....oooo and ffffiiiilllleeee3333....oooo and insert them into lllliiiibbbb.... The treatment of escaped newline characters throughout the makefile is historical practice. For example, the inference rule: .c.o\ : works, and the macro: f= bar baz\ biz a: echo ==$f== will echo ==bar baz biz==. If $? were: /usr/include/stdio.h /usr/include/unistd.h foo.h then $(?D) would be: /usr/include /usr/include . and $(?F) would be: stdio.h unistd.h foo.h 6. The contents of the built-in rules can be viewed by running: make -p -f /dev/null 2>/dev/null SSSSEEEEEEEE AAAALLLLSSSSOOOO _a_r, _c_8_9, _c_c, _g_e_t, _l_e_x, _s_h, NNNNOOOOTTTTEEEESSSS The VPATH facility is a derivation of the undocumented VPATH feature in the System V Release 3 version of _m_a_k_e. System V Release 4 has a new VPATH implementation, much like the _p_m_a_k_e(1) ....PPPPAAAATTTTHHHH feature. This new PPPPaaaaggggeeee 22220000 MMMMAAAAKKKKEEEE((((1111)))) MMMMAAAAKKKKEEEE((((1111)))) feature is also undocumented in the standard System V Release 4 manual pages. For this reason it is not available in the IRIX version of _m_a_k_e . The VPATH facility should not be used with the new parallel make option. An added feature is the ability for macros to be placed with macros. For example, when FLAGS = TYPE, then $(MAKE_${FLAGS}) will get expanded to the macro $(MAKE_TYPE). This syntax can handle about 100 levels of imbedding. CCCCOOOOMMMMPPPPAAAATTTTIIIIBBBBIIIILLLLIIIITTTTYYYY IIIISSSSSSSSUUUUEEEESSSS When the special target _...._PPPP_OOOO_SSSS_IIII_XXXX is not specified, the following backward compatible actions take place: 1. The content of the _MMMM_AAAA_KKKK_EEEE_FFFF_LLLL_AAAA_GGGG_SSSS variable will contain only the command line options and not command line macros. BBBBUUUUGGGGSSSS Filenames with the characters ==== :::: @@@@ will not work. Commands that are directly executed by the shell, notably _c_d(1), are ineffectual across new-lines in _m_a_k_e. The syntax ((((lllliiiibbbb((((ffffiiiilllleeee1111....oooo ffffiiiilllleeee2222....oooo ffffiiiilllleeee3333....oooo)))) is illegal. You cannot build lllliiiibbbb((((ffffiiiilllleeee....oooo)))) from ffffiiiilllleeee....oooo. The macro $$$$((((aaaa::::....oooo====....cccc~~~~)))) does not work. Named pipes are not handled well. PPPPaaaaggggeeee 22221111 
